Summary

• extract the loadExperimentalSyncTarget wrapper out of settings-hub on top of the latest settings leaf
• keep retrying file reads and target normalization behavior unchanged while slimming the settings facade
• add a focused test for the new experimental target loader helper

Validation

• npm run typecheck
• npm run lint -- lib/codex-manager/experimental-sync-target-entry.ts lib/codex-manager/settings-hub.ts test/experimental-sync-target-entry.test.ts
• npm run test -- test/experimental-sync-target-entry.test.ts

note: greptile review for oc-chatgpt-multi-auth. cite files like lib/foo.ts:123. confirm regression tests + windows concurrency/token redaction coverage.

Greptile Summary

clean extraction of the loadExperimentalSyncTargetEntry wrapper out of settings-hub.ts — the readJson adapter (wiring readFileWithRetry with windows-safe retry codes into a json-parse helper) is now a standalone injectable unit. behavior is a faithful 1:1 move with no logic changes.

• experimental-sync-target-entry.ts — new module; assembles readJson from readFileWithRetry + {EBUSY, EPERM, EAGAIN, ENOTEMPTY, EACCES} retry set and maxAttempts: 4, then delegates to loadExperimentalSyncTargetState
• settings-hub.ts — call-site slimmed to a simple loadExperimentalSyncTargetEntry(...) pass-through; all injected deps (readFileWithRetry, sleep, normalizeAccountStorage) are forwarded correctly
• experimental-sync-target-entry.test.ts — single delegation test added, but readFileWithRetry is never actually invoked because loadExperimentalSyncTargetState is fully mocked; the windows retry-code assembly is the key extracted behavior and it lacks a covering test

Confidence Score: 4/5

• safe to merge; one targeted test addition would fully cover the extracted windows retry-code logic
• the production code change is a pure, behavior-preserving extraction — no logic altered, windows retry codes and maxAttempts carried over exactly. the only gap is that the test doesn't exercise the readJson closure, leaving the retry-code constants unverified; a follow-up test covers it without blocking merge
• test/experimental-sync-target-entry.test.ts — readJson adapter path is untested

Important Files Changed

Sequence Diagram

sequenceDiagram
    participant SH as settings-hub.ts
    participant ESTE as experimental-sync-target-entry.ts
    participant EST as experimental-sync-target.ts
    participant RFR as readFileWithRetry

    SH->>ESTE: loadExperimentalSyncTargetEntry({ loadExperimentalSyncTargetState, detectTarget, readFileWithRetry, normalizeAccountStorage, sleep })
    note over ESTE: builds readJson closure<br/>retryableCodes: EBUSY/EPERM/EAGAIN/ENOTEMPTY/EACCES<br/>maxAttempts: 4
    ESTE->>EST: loadExperimentalSyncTargetState({ detectTarget, readJson, normalizeAccountStorage })
    EST->>RFR: readJson(path) → readFileWithRetry(path, retryOptions)
    RFR-->>EST: file contents string
    EST-->>ESTE: { kind, detection, destination? }
    ESTE-->>SH: { kind, detection, destination? }

This is a comment left during a code review.
Path: test/experimental-sync-target-entry.test.ts
Line: 5-27

Comment:
**`readJson` adapter is never exercised**

the test mocks `loadExperimentalSyncTargetState` at the top level, so the `readJson` closure (the *actual* extracted behavior — wiring `readFileWithRetry` with retry codes and `maxAttempts: 4`) is never invoked. `readFileWithRetry` spy call count stays at 0.

if someone changes the retry codes, drops `EACCES`/`EPERM`, or alters `maxAttempts`, this test will still pass. those are the windows filesystem-safety constants this project explicitly guards.

add a second `it` that captures the `readJson` arg passed into `loadExperimentalSyncTargetState` and calls it, then asserts `readFileWithRetry` was called with the expected `retryableCodes` set and `maxAttempts: 4`:

```typescript
it("builds readJson with the correct windows-safe retry codes", async () => {
    const readFileWithRetry = vi.fn(async () => '{"ok":true}');
    let capturedReadJson: ((path: string) => Promise<unknown>) | undefined;

    await loadExperimentalSyncTargetEntry({
        loadExperimentalSyncTargetState: async ({ readJson }) => {
            capturedReadJson = readJson;
            return { kind: "target", detection: { kind: "target" }, destination: null };
        },
        detectTarget: () => ({ kind: "target" }) as never,
        readFileWithRetry,
        normalizeAccountStorage: vi.fn(() => null),
        sleep: vi.fn(async () => undefined),
    });

    const result = await capturedReadJson!("/some/path");
    expect(result).toEqual({ ok: true });
    expect(readFileWithRetry).toHaveBeenCalledWith("/some/path", {
        retryableCodes: new Set(["EBUSY", "EPERM", "EAGAIN", "ENOTEMPTY", "EACCES"]),
        maxAttempts: 4,
        sleep: expect.any(Function),
    });
});
```

How can I resolve this? If you propose a fix, please make it concise.

_{Last reviewed commit: "refactor: extract ex..."}